﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
using System.Text.RegularExpressions;


namespace CapaNegocio
{
    public class Validacion
    {
        private string strIn; //Cadena a la que se asigna el valor a comprobar

        public string StrIn
        {
            get { return strIn; }
            set { strIn = value; }
        }

        public bool esValidoEmail()
        {
            // Devuelve cierto si el email es correcto. Por ejemplo: prueba@gmail.com


            return Regex.IsMatch(strIn, @"^([\w-\.]+)@([\w-\.]+)\.[a-zA-Z]{2,4}$");

        }

        public bool esValidoString()
        {
            return Regex.IsMatch(strIn, @"^[a-z|A-Z]+");
        }


    /*    public bool esValidaWeb()
        {
            // Devuelve cierto si la direccion web es correcta. Por ejemplo: http://www.google.es 

            return Regex.IsMatch(strIn, @"^(ht|f)tp(s?)\:\/\/[0-9a-zA-Z]([-.\w]*[0-9a-zA-Z])*(:(0-9)*)*(\/?)( [a-zA-Z0-9\-\.\?\,\'\/\\\+&amp;%\$#_]*)?$");
        }

        */
        public bool esValidaContrasenya()
        {
            // Devuelve cierto si la contrasenya es correcta (entre 8-10 caracteres, por lo menos un 
            //  digito y un alfanumérico, y no puede contener caracteres espaciales)

            return Regex.IsMatch(strIn, @"(?!^[0-9]*$)(?!^[a-zA-Z]*$)^([a-zA-Z0-9]{6,10})$");
        }

        public bool esValidoLogin()
        {
            // Devuelve cierto si el login es correcto (entre 8-15 caracteres, incluyendo numeros) 
            //  y no puede contener caracteres espaciales)

            return Regex.IsMatch(strIn, @"^[A-Z|a-z|0-9]{8,15}$"); 
        }

        public bool esValidaFecha()
        {
            // Devuelve cierto si la fecha es correcta. Por ejemplo: 01/01/2010 

            return Regex.IsMatch(strIn, @"^(\d{1,2}\/\d{1,2}\/\d{2,4})|(\d{1,2}\-\d{1,2}\-\d{2,4})$");
        }



        public bool esValidaMoneda()
        {
            // Devuelve cierto si la cantidad es correcta en formato moneda. Si tiene punto decimal, 
            //  requiere 2 caracteres numéricos después del punto decimal.

            return Regex.IsMatch(strIn, @"^\d+(\,\d{1,2})?$");

        }

        /*    

            public bool esValidaNumTarjeta()
            {
                // Devuelve cierto si el numero de la tarjeta es correcto 

                return Regex.IsMatch(strIn, @"^(\d{4}\-\d{4}\-\d{4}\-\d{4})$");
            }
            */


        public bool esValidoTelefono()
        {
            // Devuelve cierto si el numero de telefono es correcto 

            return Regex.IsMatch(strIn, @"^[0-9]{2,3}-? ?[0-9]{6,7}$");
        }



        public bool esValidoCodPostal()
        {
            // Devuelve cierto si el codigo postal es correcto 

            return Regex.IsMatch(strIn, @"^([1-9]{2}|[0-9][1-9]|[1-9][0-9])[0-9]{3}$");
        }

        
        public bool esValidoDNI()
        {
            // Devuelve cierto si el dni es correcto 8 digitos + Letra

            return Regex.IsMatch(strIn, @"^[0-9]{8}[A-Z|a-z]");
        }

           //Devuelve cierto si el formato de NIE es correcto Letra[X-Z] + 7 digitos + Letra de control
        public bool esValidoNIE()
        {
            return Regex.IsMatch(strIn, @"^[X-Z|x-z][0-9]{7}[A-Z|a-z]"); 

        }
        //Devuelve cierto si el formato de num de  PASAPORTE es correcto Letra[A-Z]Letra[A-Z] + 6 digitos
        public bool esValidoPasaporte()
        {
            return Regex.IsMatch(strIn, @"^[A-Z|a-z][A-Z|a-z][0-9]{6}");

        }

        /*
        public bool esValidoCCC()
        {
            // Devuelve cierto si el CCC es correcto

            return Regex.IsMatch(strIn, @"^(\d{20})$");
        }


        public bool necesitaTratamiento()
        {
            // Devuelve cierto si necesita tratamiento o falso en caso de no necesitarlo o de encontrar error

            return ((strIn.Equals("S")) || (strIn.Equals("s")));
        }

        public string letra_nif(UInt32 dni)
        {
            string s_letra = "TRWAGMYFPDXBNJZSQVHLCKE";
            dni = dni % 23;
            s_letra = s_letra[Convert.ToInt16(dni)].ToString();
            return s_letra;
        }
        */
        public bool esValidoNUMERO()
        {
            // Devuelve cierto si lo introducido en un numero, no tiene nada que ver con el dni
     
            return Regex.IsMatch(strIn, @"^[0-9]+");
     
           
        }
        public bool esUnNumero()
        {
            // Devuelve cierto si el codigo es correcto

            return Regex.IsMatch(strIn, @"^[1-9][0-9]*$");
        }
        /*
        public bool esValidoCodigo()
        {
            // Devuelve cierto si el codigo es correcto

            return Regex.IsMatch(strIn, @"^[0-9]{4}$");
        }
        */


        

        // Este metodo devuelve la letra del NIF correspondiente al dni pasado como parametro
        // en caso de dni no valido devuelve caracter vacio ''
        public char obtenerLetraNIF(string dni) 
        {
                const string Letras = "TRWAGMYFPDXBNJZSQVHLCKET";
                int n;
                if ((dni == null) || (dni.Length != 8) || (!int.TryParse(dni, out n)))
                {
                    return (' ');
                    
                }
                else return Letras[n % 23];
        
        }

        //Metodo que comprueba si la letra del NIF es la correcta se supone que antes se ha comprobado que el formato de nif es correcto 7digitos+letra
        public bool compruebaNIF() 
        {
            
            string digitos=StrIn.Substring(0,8); //Se extraen los digitos del nif
            string letra = StrIn.Substring(8,1); //Se extrae la letra
            char[] tmp = letra.ToCharArray();
            char lcalculada = obtenerLetraNIF(digitos); //Se obtiene la letra correcta para los digitos

            if (tmp[0] == lcalculada) return true; //Si las letras coinciden es correcto
            else
                return false;
        }

        //Este metodo aplica el algoritmo de cifrado SHA1 a la cadena pasada como parametro , devolviendola como texto cifrado
        public string cifrarSHA1(string pwd)
        {
            HashAlgorithm hashValue = new SHA1CryptoServiceProvider();
            byte[] bytes = System.Text.Encoding.UTF8.GetBytes(pwd);
            byte[] byteHash = hashValue.ComputeHash(bytes);
            hashValue.Clear();

            return (Convert.ToBase64String(byteHash));
        } 
    }
}